home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 July: Mac OS SDK / Dev.CD Jul 00 SDK2.toast / Development Kits / Cross Platform / QuickTime 4.1.2 Windows SDK / CIncludes / PCCard.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-04-12  |  21.2 KB  |  589 lines  |  [TEXT/R*ch]
  1. /*
  2.      File:        PCCard.h
  3.  
  4.      Contains:    PC Card Family Programming interface
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    QuickTime 4.1
  8.  
  9.      Copyright:    (c) 1996-1999 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __PCCARD__
  18. #define __PCCARD__
  19.  
  20. #ifndef __MACTYPES__
  21.     #include <MacTypes.h>
  22. #endif
  23.  
  24. #ifndef __NAMEREGISTRY__
  25.     #include <NameRegistry.h>
  26. #endif
  27.  
  28. #ifndef __MACERRORS__
  29.     #include <MacErrors.h>
  30. #endif
  31.  
  32.  
  33.  
  34.  
  35. #if PRAGMA_ONCE
  36. #pragma once
  37. #endif
  38.  
  39. #ifdef __cplusplus
  40. extern "C" {
  41. #endif
  42.  
  43. #if PRAGMA_IMPORT
  44. #pragma import on
  45. #endif
  46.  
  47. #if PRAGMA_STRUCT_ALIGN
  48.     #pragma options align=power
  49. #elif PRAGMA_STRUCT_PACKPUSH
  50.     #pragma pack(push, 2)
  51. #elif PRAGMA_STRUCT_PACK
  52.     #pragma pack(2)
  53. #endif
  54.  
  55. enum {
  56.     kServiceCategoryPCCard        = FOUR_CHAR_CODE('pccd')
  57. };
  58.  
  59.  
  60. typedef UInt32                             PCCardEvent;
  61. typedef UInt32                             PCCardEventMask;
  62. typedef UInt32                             PCCardClientID;
  63. typedef UInt32                             PCCardTimerID;
  64. typedef UInt32                             PCCardSocket;
  65. typedef UInt32                             PCCardWindowID;
  66. typedef UInt32                             PCCardWindowType;
  67. typedef UInt32                             PCCardWindowSize;
  68. typedef UInt32                             PCCardWindowOffset;
  69. typedef UInt32                             PCCardWindowAlign;
  70. typedef OptionBits                         PCCardWindowState;
  71. typedef UInt32                             PCCardAccessSpeed;
  72. typedef UInt32                             PCCardWindowParam;
  73. typedef UInt32                             PCCardPage;
  74. typedef UInt32                             PCCardVoltage;
  75. /*
  76.     Several of the client notification bit flags have been REMOVED since the first
  77.     release of this header.  These were unused codes that were either
  78.     copied directly from PC Card 2.x, or from the PCMCIA standard.  In all cases,
  79.     they were completely unimplemented and would never be sent under PCCard 3.0.
  80.     
  81.     The removed flags are:
  82.         kPCCardClientInfoMessage, kPCCardSSUpdatedMessage,
  83.         and kPCCardFunctionInterruptMessage.
  84.     
  85.     If your software used any of these flags, you should delete any references
  86.     to them.  These event codes are being recycled for new features.
  87. */
  88. /* Client notification bit flags */
  89. enum {
  90.     kPCCardNullMessage            = 0x00000000,                    /* no messages pending (not sent to clients)*/
  91.     kPCCardInsertionMessage        = 0x00000001,                    /* card has been inserted into the socket*/
  92.     kPCCardRemovalMessage        = 0x00000002,                    /* card has been removed from the socket- do not touch hardware!*/
  93.                                                                 /* Lock and Unlock may be used for a hardware locking card-cage. */
  94.     kPCCardLockMessage            = 0x00000004,                    /* card is locked into the socket with a mechanical latch */
  95.     kPCCardUnlockMessage        = 0x00000008,                    /* card is no longer locked into the socket */
  96.                                                                 /* Ready and Reset are holdovers from PC Card 2.x, but someone might be using them (!?) */
  97.     kPCCardReadyMessage            = 0x00000010,                    /* card is ready to be accessed -- do not use! this event is never sent! (use kPCCardInsertion instead) */
  98.     kPCCardResetMessage            = 0x00000020,                    /* physical reset has completed -- do not use! this event is never sent! (use kPCCardResetComplete instead) */
  99.                                                                 /* InsertionRequest and InsertionComplete may be used with certain cages (??) */
  100.     kPCCardInsertionRequestMessage = 0x00000040,                /* request to insert a card using insertion motor */
  101.     kPCCardInsertionCompleteMessage = 0x00000080,                /* insertion motor has finished inserting a card */
  102.     kPCCardEjectionRequestMessage = 0x00000100,                    /* user or other client is requesting a card ejection*/
  103.     kPCCardEjectionCompleteMessage = 0x00000200,                /* card ejection succeeded- do not touch hardware! */
  104.     kPCCardEjectionFailedMessage = 0x00000400,                    /* eject failure due to electrical/mechanical problems*/
  105.     kPCCardPMResumeMessage        = 0x00000800,                    /* power management resume */
  106.     kPCCardPMSuspendMessage        = 0x00001000,                    /* power management suspend */
  107.     kPCCardPMSuspendRequest        = 0x00002000,                    /* power management sleep request */
  108.     kPCCardPMSuspendRevoke        = 0x00004000,                    /* power management sleep revoke */
  109.     kPCCardResetPhysicalMessage    = 0x00008000,                    /* physical reset is about to occur on this card -- this event is never sent! */
  110.     kPCCardResetRequestMessage    = 0x00010000,                    /* physical reset has been requested by a client*/
  111.     kPCCardResetCompleteMessage    = 0x00020000,                    /* ResetCard() background reset has completed*/
  112.     kPCCardBatteryDeadMessage    = 0x00040000,                    /* battery is no longer useable, data will be lost*/
  113.     kPCCardBatteryLowMessage    = 0x00080000,                    /* battery is weak and should be replaced*/
  114.     kPCCardWriteProtectMessage    = 0x00100000,                    /* card is now write protected*/
  115.     kPCCardWriteEnabledMessage    = 0x00200000,                    /* card is now write enabled*/
  116.     kPCCardDisplayEjectDSATMessage = 0x00400000,                /* about to display a DSAT for the user to re-insert a manually ejected card */
  117.     kPCCardUnexpectedRemovalMessage = 0x02000000,                /* card has unexpectedly been manually ejected */
  118.                                                                 /* Unconfigured is a (currently unused) holdover from PC Card 2.x */
  119.     kPCCardUnconfiguredMessage    = 0x04000000,                    /* a CARD_READY was delivered to all clients and no client */
  120.                                                                 /*    requested a configuration for the socket -- this event is never sent under PCCard 3.0! */
  121.     kPCCardStatusChangedMessage    = 0x08000000,                    /* status change for cards in I/O mode*/
  122.     kPCCardTimerExpiredMessage    = 0x10000000,                    /* message sent when requested time has expired */
  123.     kPCCardRequestAttentionMessage = 0x20000000,
  124.     kPCCardEraseCompleteMessage    = 0x40000000,
  125.     kPCCardRegistrationCompleteMessage = (long)0x80000000,        /* notifications available only in PCCard 3.1 and later */
  126.     kPCCardPMEnabledMessage        = 0x00800000                    /* power management has been enabled by the user; if appropriate, clients should call PCCardSetPowerLevel(off) */
  127. };
  128.  
  129. typedef OptionBits                         PCCardWindowAttributes;
  130. /*    window state (values of PCCardWindowAttributes) */
  131. enum {
  132.     kWSCommon                    = 0x0001,                        /* common memory window */
  133.     kWSAttribute                = 0x0002,                        /* attribute memory window*/
  134.     kWSIO                        = 0x0004,                        /* I/O window*/
  135.     kWSCardBus                    = 0x0800,                        /* CardBus bridge window */
  136.     kWSTypeMask                    = 0x0807,                        /* window type mask*/
  137.     kWSEnabled                    = 0x0008,                        /* window enabled*/
  138.     kWS8bit                        = 0x0010,                        /* 8-bit data width window*/
  139.     kWS16bit                    = 0x0020,                        /* 16-bit data width window*/
  140.     kWS32bit                    = 0x0040,                        /* 32-bit data width window*/
  141.     kWSAutoSize                    = 0x0080,                        /* auto-size data width window*/
  142.     kWSWidthMask                = 0x00F0,                        /* window data width mask*/
  143.     kWSProtected                = 0x0100,                        /* window write protected*/
  144.     kWSPrefetchable                = 0x0200,                        /* bridge window prefetchable*/
  145.     kWSPageShared                = 0x0400,                        /* page register is shared*/
  146.     kWSWindowSizeOffset            = 0x4000,
  147.     kWSChangeAccessSpeed        = 0x8000                        /* Used by CSModifyWindow only */
  148. };
  149.  
  150. /* window speed (sample values of PCCardAccessSpeed) for use in PCCardRequestWindow  */
  151. enum {
  152.     kAccessSpeed600ns            = 0x006A,
  153.     kAccessSpeed500ns            = 0x005A,
  154.     kAccessSpeed400ns            = 0x004A,
  155.     kAccessSpeed300ns            = 0x003A,
  156.     kAccessSpeed250ns            = 0x0001,
  157.     kAccessSpeed200ns            = 0x0002,
  158.     kAccessSpeed150ns            = 0x0003,
  159.     kAccessSpeed100ns            = 0x0004
  160. };
  161.  
  162. typedef UInt32                             PCCardInterfaceType;
  163. /* InterfaceType bit-mask (values of PCCardInterfaceType) */
  164. enum {
  165.     kIFTypeMask                    = 0x03,                            /* IO & memory type mask*/
  166.     kIFCardBus                    = 0x00,                            /* if bits 0 & 1 are zero then cardbus interface*/
  167.     kIFMemory                    = 0x01,                            /* if bit 0 set memory IF*/
  168.     kIFIO                        = 0x02,                            /* if bit 1 set IO IF*/
  169.     kIFReserved                    = 0x03,                            /* bits 0 and 1 set is reserved */
  170.     kIFDMA                        = 0x08,                            /* if bit 3 set DMA supported*/
  171.     kIFVSKey                    = 0x10,                            /* if bit 4 set supports low Voltage key*/
  172.     kIF33VCC                    = 0x20,                            /* if bit 5 set socket suports 3.3v*/
  173.     kIFXXVCC                    = 0x40,                            /* if bit 6 set socket supports X.X voltage*/
  174.     kIFYYVCC                    = 0x80                            /* if bit 7 set socket supports Y.Y voltage*/
  175. };
  176.  
  177. typedef UInt32                             PCCardCustomInterfaceID;
  178. /* Custom Interface Identifiers (values of PCCardCustomInterfaceID) */
  179. enum {
  180.     kIFCustom_None                = 0x00,                            /* no custom interface ID */
  181.     kIFCustom_ZOOM                = 0x41                            /* ZOOM Video Mode custom interface identifier */
  182. };
  183.  
  184. typedef OptionBits                         PCCardConfigOptions;
  185. /* Bit mask values for PCCardConfigOptions in the configuration calls */
  186. enum {
  187.     kEnableIRQSteering            = 0x0002,
  188.     kIRQChangeValid                = 0x0004,
  189.     kVppChangeValid                = 0x0010,
  190.     kEnableDMAChannel            = 0x0040,
  191.     kDMAChangeValid                = 0x0080,
  192.     kVSOverride                    = 0x0200                        /* Bits 10..31 reserved */
  193. };
  194.  
  195. /*
  196.    Configuration Registers Presence Mask for the FCR
  197.    Used by PCCardConfigPresentMask
  198. */
  199. enum {
  200.     kConfigOptionPresent        = 0x00000001,
  201.     kConfigStatusPresent        = 0x00000002,
  202.     kPinReplacePresent            = 0x00000004,
  203.     kSocketCopyPresent            = 0x00000008,
  204.     kExtendedStatusPresent        = 0x00000010,
  205.     kIOBase0Present                = 0x00000020,
  206.     kIOBase1Present                = 0x00000040,
  207.     kIOBase2Present                = 0x00000080,
  208.     kIOBase3Present                = 0x00000100,
  209.     kIOLimitPresent                = 0x00000200
  210. };
  211.  
  212. typedef UInt32                             PCCardConfigPresentMask;
  213. typedef UInt32                             PCCardConfigRegisterIndex;
  214. typedef UInt32                             PCCardConfigRegisterOffset;
  215.  
  216. struct PCCardFunctionConfigReg {
  217.     Byte                             configOptionReg;
  218.     Byte                             configStatusReg;
  219.     Byte                             pinReplaceReg;
  220.     Byte                             socketCopyReg;
  221.     Byte                             extendedStatusReg;
  222.     Byte                             ioBase0;
  223.     Byte                             ioBase1;
  224.     Byte                             ioBase2;
  225.     Byte                             ioBase3;
  226.     Byte                             ioLimit;
  227. };
  228. typedef struct PCCardFunctionConfigReg    PCCardFunctionConfigReg;
  229.  
  230. typedef OptionBits                         PCCardSocketStatus;
  231. /*    general socket status bits (values of PCCardSocketStatus) */
  232. enum {
  233.     kSTBatteryDead                = 0x0001,                        /* battery dead*/
  234.     kSTBatteryLow                = 0x0002,                        /* battery low*/
  235.     kSTBatteryGood                = 0x0004,                        /* battery good*/
  236.     kSTPower                    = 0x0008,                        /* power is applied*/
  237.     kST16bit                    = 0x0010,                        /* 16-bit PC Card present*/
  238.     kSTCardBus                    = 0x0020,                        /* CardBus PC Card present*/
  239.     kSTMemoryCard                = 0x0040,                        /* memory card present*/
  240.     kSTIOCard                    = 0x0080,                        /* I/O card present*/
  241.     kSTNotACard                    = 0x0100,                        /* unrecognizable PC Card detected*/
  242.     kSTReady                    = 0x0200,                        /* ready*/
  243.     kSTWriteProtect                = 0x0400,                        /* card is write-protected*/
  244.     kSTDataLost                    = 0x0800,                        /* data may have been lost due to card removal*/
  245.     kSTRingIndicate                = 0x1000,                        /* ring indicator is active*/
  246.     kSTReserved                    = 0xE000
  247. };
  248.  
  249. /* Bit mask for PCCardPowerOptions in the power management calls */
  250. typedef OptionBits                         PCCardPowerOptions;
  251. enum {
  252.     kPCCardPowerOn                = 0x00000001,
  253.     kPCCardPowerOff                = 0x00000002,
  254.     kPCCardLowPower                = 0x00000004
  255. };
  256.  
  257. typedef OptionBits                         PCCardAdapterCapabilities;
  258. typedef UInt32                             PCCardAdapterPowerState;
  259. typedef OptionBits                         PCCardSCEvents;
  260. typedef UInt32                             PCCardWindow;
  261. typedef UInt32                             PCCardIRQ;
  262. typedef UInt32                             PCCardDMA;
  263. /* Selectors for PCCardGetGlobalOptions */
  264. /*    The type of the "value" parameter is provided for each selector. */
  265. typedef UInt32                             PCCardOptionSelector;
  266. enum {
  267.     kPCCardPowerManagementAttrib = 1                            /* value = (Boolean*) enabled  */
  268. };
  269.  
  270.  
  271.  
  272. /* Types and structures for accessing the PCCard Assigned-Address property.*/
  273.  
  274. #define kPCCardAssignedAddressProperty "assigned-addresses"
  275. enum {
  276.     kPCCardNonRelocatableSpace    = 0x80,
  277.     kPCCardPrefetchableSpace    = 0x40,
  278.     kPCCard16BitSpace            = 0x20,
  279.     kPCCardAddressTypeCodeMask    = 0x07,
  280.     kPCCardConfigSpace            = 0,
  281.     kPCCardIOSpace                = 1,
  282.     kPCCardMemorySpace            = 2,
  283.     kPCCardAttributeMemorySpace    = 4
  284. };
  285.  
  286. typedef UInt8                             PCCardAddressSpaceFlags;
  287. enum {
  288.     kPCCardSocketNumberMask        = 0xF8,
  289.     kPCCardFunctionNumberMask    = 0x07
  290. };
  291.  
  292. typedef UInt8                             PCCardSocketFunction;
  293. typedef UInt8                             PCCardBusNumber;
  294. typedef UInt8                             PCCardRegisterNumber;
  295. /*
  296.    note: this structure is similar, but not the same as the PCIAssignedAddress structure
  297.          16-bit cards use this structure, CardBus cards use PCIAssignedAddress
  298. */
  299.  
  300. struct PCCardAssignedAddress {
  301.     PCCardAddressSpaceFlags         addressSpaceFlags;
  302.     UInt8                             reserved;
  303.     PCCardSocketFunction             socketFunctionNumber;
  304.     PCCardRegisterNumber             registerNumber;
  305.     UInt32                             address;
  306.     UInt32                             size;
  307. };
  308. typedef struct PCCardAssignedAddress    PCCardAssignedAddress;
  309. typedef PCCardAssignedAddress *            PCCardAssignedAddressPtr;
  310. #define GetPCCardIsNonRelocatable( AssignedAddressPtr )        ((AssignedAddressPtr)->addressSpaceFlags & kPCCardNonRelocatableSpace)
  311. #define GetPCCardIsPrefetchable( AssignedAddressPtr )        ((AssignedAddressPtr)->addressSpaceFlags & kPCCardPrefetchableSpace)
  312. #define GetPCCardIs16BitSpace( AssignedAddressPtr )            ((AssignedAddressPtr)->addressSpaceFlags & kPCCard16BitSpace)
  313. #define GetPCCardAddressSpaceType( AssignedAddressPtr )        ((AssignedAddressPtr)->addressSpaceFlags & kPCCardAddressTypeCodeMask)
  314. #define GetPCCardSocketNumber( AssignedAddressPtr )            (((AssignedAddressPtr)->socketFunctionNumber & kPCCardSocketNumberMask) >> 3)
  315. #define GetPCCardFunctionNumber( AssignedAddressPtr )        ((AssignedAddressPtr)->socketFunctionNumber & kPCCardFunctionNumberMask)
  316. #define GetPCCardRegisterNumber( AssignedAddressPtr )        ((AssignedAddressPtr)->registerNumber)
  317. /*----------------------------------------------------------------------
  318.     Client Support
  319. ----------------------------------------------------------------------*/
  320. /* Prototype for client callback */
  321. typedef CALLBACK_API_C( OSStatus , PCCardEventHandler )(PCCardEvent theEvent, PCCardSocket vSocket, UInt32 device, UInt32 info, UInt32 MTDRequest, UInt32 *Buffer, UInt32 misc, UInt32 status, void *clientParam);
  322. EXTERN_API_C( OSStatus )
  323. PCCardRegisterClient            (const RegEntryID *        deviceRef,
  324.                                  PCCardEventMask         eventMask,
  325.                                  PCCardEventHandler     clientCallBack,
  326.                                  void *                    clientParam,
  327.                                  PCCardClientID *        newClientID);
  328.  
  329. EXTERN_API_C( OSStatus )
  330. PCCardDeRegisterClient            (PCCardClientID         theClientID);
  331.  
  332. EXTERN_API_C( OSStatus )
  333. PCCardRegisterTimer                (PCCardClientID         registeredClientID,
  334.                                  PCCardTimerID *        lpNewTimerID,
  335.                                  long                     delay);
  336.  
  337. EXTERN_API_C( void )
  338. PCCardDeRegisterTimer            (PCCardTimerID             timerID);
  339.  
  340. EXTERN_API_C( OSStatus )
  341. PCCardSetEventMask                (PCCardClientID         theClientID,
  342.                                  PCCardEventMask         newEventMask);
  343.  
  344. EXTERN_API_C( OSStatus )
  345. PCCardGetEventMask                (PCCardClientID         theClientID,
  346.                                  PCCardEventMask *        newEventMask);
  347.  
  348. EXTERN_API_C( OSStatus )
  349. PCCardGetCardServicesInfo        (ItemCount *            socketCount,
  350.                                  UInt32 *                complianceLevel,
  351.                                  UInt32 *                version);
  352.  
  353. EXTERN_API_C( OSStatus )
  354. PCCardGetSocketRef                (PCCardSocket             vSocket,
  355.                                  RegEntryID *            socketRef);
  356.  
  357. EXTERN_API_C( OSStatus )
  358. PCCardGetCardRef                (PCCardSocket             vSocket,
  359.                                  RegEntryID *            cardRef);
  360.  
  361. EXTERN_API_C( OSStatus )
  362. PCCardGetDeviceRef                (PCCardSocket             vSocket,
  363.                                  UInt32                 device,
  364.                                  RegEntryID *            deviceRef);
  365.  
  366. EXTERN_API_C( OSStatus )
  367. PCCardGetSocketAndDeviceFromDeviceRef (const RegEntryID * deviceRef,
  368.                                  PCCardSocket *            vSocket,
  369.                                  UInt32 *                device);
  370.  
  371. EXTERN_API_C( OSStatus )
  372. PCCardGetCardRefFromDeviceRef    (const RegEntryID *        deviceRef,
  373.                                  RegEntryID *            cardRef);
  374.  
  375.  
  376. /*----------------------------------------------------------------------
  377.     Resource Management
  378. ----------------------------------------------------------------------*/
  379. EXTERN_API_C( OSStatus )
  380. PCCardRequestWindow                (const RegEntryID *        deviceRef,
  381.                                  PCCardWindowAttributes  windowAttributes,
  382.                                  LogicalAddress *        windowBase,
  383.                                  ByteCount *            windowSize,
  384.                                  PCCardAccessSpeed *    windowSpeed,
  385.                                  PCCardWindowOffset *    windowOffset,
  386.                                  PCCardWindowID *        windowID);
  387.  
  388. EXTERN_API_C( OSStatus )
  389. PCCardModifyWindow                (PCCardWindowID         windowID,
  390.                                  PCCardWindowAttributes  windowAttributes,
  391.                                  PCCardAccessSpeed         windowSpeed,
  392.                                  PCCardWindowOffset     windowOffset);
  393.  
  394. EXTERN_API_C( OSStatus )
  395. PCCardReleaseWindow                (PCCardWindowID         windowID);
  396.  
  397. EXTERN_API_C( OSStatus )
  398. PCCardInquireWindow                (const RegEntryID *        deviceRef,
  399.                                  PCCardWindowID         windowID,
  400.                                  PCCardWindowAttributes * windowAttributes,
  401.                                  LogicalAddress *        windowBase,
  402.                                  ByteCount *            windowSize,
  403.                                  PCCardAccessSpeed *    windowSpeed,
  404.                                  PCCardWindowOffset *    windowOffset);
  405.  
  406. EXTERN_API_C( OSStatus )
  407. PCCardGetStatus                    (const RegEntryID *        deviceRef,
  408.                                  UInt32 *                currentState,
  409.                                  UInt32 *                changedState,
  410.                                  PCCardVoltage *        Vcc,
  411.                                  PCCardVoltage *        Vpp);
  412.  
  413. EXTERN_API_C( OSStatus )
  414. PCCardRequestConfiguration        (const RegEntryID *        deviceRef,
  415.                                  PCCardConfigOptions     configOptions,
  416.                                  PCCardInterfaceType     ifType,
  417.                                  PCCardCustomInterfaceID  ifCustomType,
  418.                                  PCCardVoltage             vcc,
  419.                                  PCCardVoltage             vpp,
  420.                                  LogicalAddress         configRegistersBase,
  421.                                  PCCardConfigPresentMask  configRegistersPresent,
  422.                                  PCCardFunctionConfigReg * configRegisterValues);
  423.  
  424. EXTERN_API_C( OSStatus )
  425. PCCardReleaseConfiguration        (const RegEntryID *        deviceRef);
  426.  
  427. EXTERN_API_C( OSStatus )
  428. PCCardModifyConfiguration        (const RegEntryID *        deviceRef,
  429.                                  PCCardConfigOptions     configOptions,
  430.                                  PCCardVoltage             vpp);
  431.  
  432. EXTERN_API_C( OSStatus )
  433. PCCardReadConfigurationRegister    (const RegEntryID *        deviceRef,
  434.                                  PCCardConfigRegisterIndex  whichRegister,
  435.                                  PCCardConfigRegisterOffset  offset,
  436.                                  UInt8 *                value);
  437.  
  438. EXTERN_API_C( OSStatus )
  439. PCCardWriteConfigurationRegister (const RegEntryID *    deviceRef,
  440.                                  PCCardConfigRegisterIndex  whichRegister,
  441.                                  PCCardConfigRegisterOffset  offset,
  442.                                  UInt8                     value);
  443.  
  444. EXTERN_API_C( OSStatus )
  445. PCCardResetFunction                (const RegEntryID *        deviceRef);
  446.  
  447. /*----------------------------------------------------------------------
  448.     Client Utilities
  449. ----------------------------------------------------------------------*/
  450.  
  451. typedef UInt8                             PCCardTupleKind;
  452. typedef struct OpaquePCCardTupleIterator*  PCCardTupleIterator;
  453. EXTERN_API_C( PCCardTupleIterator )
  454. PCCardNewTupleIterator            (void);
  455.  
  456. EXTERN_API_C( OSStatus )
  457. PCCardDisposeTupleIterator        (PCCardTupleIterator     tupleIterator);
  458.  
  459. EXTERN_API_C( OSStatus )
  460. PCCardGetFirstTuple                (const RegEntryID *        deviceID,
  461.                                  PCCardTupleKind         desiredTuple,
  462.                                  PCCardTupleIterator     tupleIterator,
  463.                                  void *                    dataBuffer,
  464.                                  UInt32 *                dataBufferSize,
  465.                                  PCCardTupleKind *        foundTuple,
  466.                                  UInt32 *                foundTupleDataSize);
  467.  
  468. EXTERN_API_C( OSStatus )
  469. PCCardGetNextTuple                (const RegEntryID *        deviceRef,
  470.                                  PCCardTupleKind         desiredTuple,
  471.                                  PCCardTupleIterator     tupleIterator,
  472.                                  void *                    dataBuffer,
  473.                                  UInt32 *                dataBufferSize,
  474.                                  PCCardTupleKind *        foundTuple,
  475.                                  UInt32 *                foundTupleDataSize);
  476.  
  477. /*----------------------------------------------------------------------
  478.     Miscellaneous
  479. ----------------------------------------------------------------------*/
  480. EXTERN_API_C( OSStatus )
  481. PCCardEject                        (const RegEntryID *        cardRef);
  482.  
  483. EXTERN_API_C( OSStatus )
  484. PCCardEnableModemSound            (const RegEntryID *        cardRef,
  485.                                  Boolean                 enableSound);
  486.  
  487. EXTERN_API_C( OSStatus )
  488. PCCardEnableZoomedVideo            (const RegEntryID *        cardRef,
  489.                                  Boolean                 enableZoomedVideo);
  490.  
  491. EXTERN_API_C( OSStatus )
  492. PCCardEnableZoomedVideoSound    (const RegEntryID *        cardRef,
  493.                                  Boolean                 enableSound);
  494.  
  495. EXTERN_API_C( OSStatus )
  496. PCCardSetPowerLevel                (const RegEntryID *        deviceRef,
  497.                                  PCCardPowerOptions     powerLevel);
  498.  
  499. EXTERN_API_C( OSStatus )
  500. PCCardSetRingIndicate            (const RegEntryID *        deviceRef,
  501.                                  Boolean                 setRingIndicate);
  502.  
  503. EXTERN_API_C( OSStatus )
  504. PCCardGetGlobalOptions            (PCCardOptionSelector     selector,
  505.                                  void *                    value);
  506.  
  507. typedef UInt32                             PCCardDevType;
  508. typedef UInt32                             PCCardSubType;
  509. /* values for PCCardType and PCCardSubType*/
  510. enum {
  511.     kPCCardUnknownType            = 0,
  512.     kPCCardMultiFunctionType    = 1,
  513.     kPCCardMemoryType            = 2,
  514.     kPCCardNullSubType            = 0,                            /* Memory sub types */
  515.     kPCCardRomSubType            = 1,
  516.     kPCCardOTPromSubType        = 2,
  517.     kPCCardEpromSubType            = 3,
  518.     kPCCardEEpromSubType        = 4,
  519.     kPCCardFlashSubType            = 5,
  520.     kPCCardSramSubType            = 6,
  521.     kPCCardDramSubType            = 7,
  522.     kPCCardSerialPortType        = 3,
  523.     kPCCardSerialOnlySubType    = 0,
  524.     kPCCardDataModemSubType        = 1,
  525.     kPCCardFaxModemSubType        = 2,
  526.     kPCCardFaxAndDataModemMask    = (kPCCardDataModemSubType | kPCCardFaxModemSubType),
  527.     kPCCardVoiceEncodingSubType    = 4,
  528.     kPCCardParallelPortType        = 4,
  529.     kPCCardFixedDiskType        = 5,
  530.     kPCCardUnknownFixedDiskType    = 0,
  531.     kPCCardATAInterfaceDiskSubType = 1,
  532.     kPCCardRotatingDeviceSubType = (0 << 7),
  533.     kPCCardSiliconDevice        = (1 << 7),
  534.     kPCCardVideoAdaptorType        = 6,
  535.     kPCCardNetworkAdaptorType    = 7,
  536.     kPCCardArcNetSubType        = 1,                            /* network sub types */
  537.     kPCCardEthernetSubType        = 2,
  538.     kPCCardTokenRingSubType        = 3,
  539.     kPCCardLocalTalkSubType        = 4,
  540.     kPCCardFDDI_CDDISubType        = 5,
  541.     kPCCardATMSubType            = 6,
  542.     kPCCardWirelessSubType        = 7,
  543.     kPCCardAIMSType                = 8,
  544.     kPCCardSCSIType                = 9,
  545.     kPCCardSerialBusType        = 10,
  546.     kPCCardUSBBusSubType        = 1,
  547.     kPCCardFirewireBusSubType    = 2
  548. };
  549.  
  550. EXTERN_API_C( OSStatus )
  551. PCCardGetCardInfo                (const RegEntryID *        cardRef,
  552.                                  PCCardDevType *        cardType,
  553.                                  PCCardSubType *        cardSubType,
  554.                                  StringPtr                 cardName,
  555.                                  StringPtr                 vendorName);
  556.  
  557. enum {
  558.     kPCCard16HardwareType        = FOUR_CHAR_CODE('pc16'),
  559.     kCardBusHardwareType        = FOUR_CHAR_CODE('cdbs')
  560. };
  561.  
  562. typedef UInt32                             PCCardHardwareType;
  563. EXTERN_API_C( OSStatus )
  564. PCCardGetCardType                (const RegEntryID *        socketRef,
  565.                                  PCCardHardwareType *    cardType);
  566.  
  567.  
  568.  
  569. #if PRAGMA_STRUCT_ALIGN
  570.     #pragma options align=reset
  571. #elif PRAGMA_STRUCT_PACKPUSH
  572.     #pragma pack(pop)
  573. #elif PRAGMA_STRUCT_PACK
  574.     #pragma pack()
  575. #endif
  576.  
  577. #ifdef PRAGMA_IMPORT_OFF
  578. #pragma import off
  579. #elif PRAGMA_IMPORT
  580. #pragma import reset
  581. #endif
  582.  
  583. #ifdef __cplusplus
  584. }
  585. #endif
  586.  
  587. #endif /* __PCCARD__ */
  588.  
  589.